/*******************************************************************************
  * 文件：TimingCtrl.c
  * 作者：djy
  * 版本：v1.0.0
  * 日期：2020.12.04
  * 说明：定时控制
*******************************************************************************/
#include "TimingCtrl.h"
#include "StateMachine.h"
#include "BuzCtrl.h"
#include "FireCtrl.h"

static DevTiming_ts sDevTiming;

Bool Timing_CheckRightTimingExpire(void)
{
    return OS_TimerIsActive(&(sDevTiming.asTimingCtrl[2].sExpireTimer));
}

static void Timing_RightShowENHook_1S(void)
{
    if(eDEV_RIGHT_TIMING != StateMachine_GetCurState())
    {
        // 右定时模式不在前台，关闭右灶LED
        LED_RightTimingCtrl(eLED_OFF);
    }   
    else
    {
        // 右定时在前台，闪烁EN
        if(1== OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[2].sExpireTimer))%2)
        {
            SMG_AllOff();
        }
        else
        {
            SMG_ShowSymbol(eEN);
        }    
    }

    // 10S时间到
    if(10 == OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[2].sExpireTimer)))
    {
        // 若右灶定时还在前台
        if(eDEV_RIGHT_TIMING == StateMachine_GetCurState())
        {
            // 切换到其他定时模式
            if(ON == Timing_CheckLeftTimingRun())
            {
                // 切换到左灶定时模式
                StateMachine_Change(eDEV_LEFT_TIMING);
            }
            else if(ON == Timing_CheckMidTimingRun())
            {
                // 切换到中灶定时模式
                StateMachine_Change(eDEV_MID_TIMING);
            }
            else 
            {
                // 切换到待机模式
                StateMachine_Change(eDEV_STANDBY);
            }            
        }
        
        // LED灭
        LED_RightTimingCtrl(eLED_OFF);
        // 停止定时器
        OS_TimerStop(&(sDevTiming.asTimingCtrl[2].sExpireTimer));
    }
}

static void Timing_RightTimignExpire(void)
{
    sDevTiming.asTimingCtrl[2].bCountDownFlag = FALSE; // 清除运行标志
    sDevTiming.asTimingCtrl[2].u16TimingMin = 0; // 定时时间清零
    sDevTiming.asTimingCtrl[2].u32TimingMS  = 0; // 定时时间清
    RightStoveFireOff();// 关火

    // 判断当前是否为右灶定时显示
    if(eDEV_RIGHT_TIMING == StateMachine_GetCurState())
    {
        // 显示EN
        SMG_ShowSymbol(eEN);
        BuzCtrl(eBUZ_TIME_OUT);
    }
    else
    {
        // LED灭
        LED_RightTimingCtrl(eLED_OFF); 
    }

    // 启动定时结束定时器，倒计时十秒
    OS_TimerStart(&(sDevTiming.asTimingCtrl[2].sExpireTimer),1000,Timing_RightShowENHook_1S);
}

void Timing_StopRightTiming(void)
{
    sDevTiming.asTimingCtrl[2].bCountDownFlag = FALSE; // 清除运行标志
    sDevTiming.asTimingCtrl[2].u16TimingMin = 0; // 定时时间清零
    sDevTiming.asTimingCtrl[2].u32TimingMS  = 0; // 定时时间清
    LED_RightTimingCtrl(eLED_OFF); // LED灭

    // 若已经在显示EN，关停蜂鸣器
    if(TRUE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[2].sExpireTimer)))
    {
        BuzStop();
    }
    
    // 判断当前是否为右定时模式
    if(eDEV_RIGHT_TIMING == StateMachine_GetCurState())
    {
        // 切换到其他定时模式
        if(ON == Timing_CheckLeftTimingRun())
        {
            // 切换到左灶定时模式
            StateMachine_Change(eDEV_LEFT_TIMING);
        }
        else if(ON == Timing_CheckMidTimingRun())
        {
            // 切换到右灶定时模式
            StateMachine_Change(eDEV_MID_TIMING);
        }
        else 
        {
            // 切换到待机模式
            StateMachine_Change(eDEV_STANDBY);
        } 
    }
}

Bool Timing_CheckRightTimingRun(void)
{
  	if(TRUE == sDevTiming.asTimingCtrl[2].bCountDownFlag
	   	|| TRUE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[2].sFlashTimer)))
	{
	  	return TRUE;
	}
	else
	{
	  	return FALSE;
	}
}

Bool Timing_CheckRightFlashTimerActive(void)
{
    return OS_TimerIsActive(&(sDevTiming.asTimingCtrl[2].sFlashTimer));
}

static void Timing_RightFlashHook_500MS(void)
{
    if(eDEV_RIGHT_TIMING != StateMachine_GetCurState())
    {
        // 不是在右定时模式，直接退出
        OS_TimerStop(&(sDevTiming.asTimingCtrl[2].sFlashTimer));
        return;
    }

    // 定时时间闪烁
    if(OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[2].sFlashTimer))%2)
    {
        // 数码管灭
        SMG_AllOff();
        SMG_IconMinute(OFF);
        // 右灶定时按键灭
        LED_RightTimingCtrl(eLED_OFF);
    }
    else
    {
        // 显示时间
        SMG_ShowNum(sDevTiming.asTimingCtrl[2].u16TimingMin);
        SMG_IconMinute(ON);
        // 右灶定时按键全亮
        LED_RightTimingCtrl(eLED_ON);
    }

    // 定时器到期6次，闪烁三次
    if(6 == OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[2].sFlashTimer)))
    {
        LED_AddCtrl(eLED_OFF);// 加键灭        
        LED_SubCtrl(eLED_OFF);// 减键灭
        
        // 若定时时间修改为0，结束定时
        if(sDevTiming.asTimingCtrl[2].u16TimingMin == 0)
        {
            // 右灶定时结束，不关火
            Timing_StopRightTiming();
        }
        else
        {
            // 启动倒计时
            sDevTiming.asTimingCtrl[2].bCountDownFlag = TRUE; 
        }
        // 停止闪烁定时器
        OS_TimerStop(&(sDevTiming.asTimingCtrl[2].sFlashTimer));
        return;
    }

}

void Timing_ComfirmRightTimingTime(void)
{
    LED_AddCtrl(eLED_OFF);// 加键灭        
    LED_SubCtrl(eLED_OFF);// 减键灭

    // 若定时时间修改为0，结束定时
    if(sDevTiming.asTimingCtrl[2].u16TimingMin == 0)
    {
        // 右灶定时结束，不关火
        Timing_StopRightTiming();
    }
    else
    {
        // 启动倒计时
        sDevTiming.asTimingCtrl[2].bCountDownFlag = TRUE; 
        SMG_ShowNum(sDevTiming.asTimingCtrl[2].u16TimingMin);// 显示时间
        SMG_IconMinute(ON);
        LED_RightTimingCtrl(eLED_ON);// 右灶定时按键全亮
    }
    // 停止闪烁定时器
    OS_TimerStop(&(sDevTiming.asTimingCtrl[2].sFlashTimer));
}

U8 Timing_GetRightTimingTime(void)
{
    return (U8)sDevTiming.asTimingCtrl[2].u16TimingMin;
}

Bool Timing_ChangeRightTimingTime(U8 u8Time)
{
    if(u8Time > 180)
    {
        return FALSE;
    }

    // 检查定时是否运行
    if(ON == Timing_CheckRightTimingRun())
    {
        // 定时器正在运行，定时时间修改
        if(u8Time != 0)
        {
            // 定时时间不为0，修改定时时间
            sDevTiming.asTimingCtrl[2].u16TimingMin = u8Time; 
            // 定时时间换算为ms
            sDevTiming.asTimingCtrl[2].u32TimingMS = (U32)sDevTiming.asTimingCtrl[2].u16TimingMin
                                                            * 60
                                                            * 1000;   
            // 暂停倒计时
            sDevTiming.asTimingCtrl[2].bCountDownFlag = FALSE;
            // 右灶定时切换至前台
            StateMachine_Change(eDEV_RIGHT_TIMING);
            // 加键亮
            LED_AddCtrl(eLED_ON);
            // 减键亮
            LED_SubCtrl(eLED_ON);
            // 启动定时器
            OS_TimerRestart(&(sDevTiming.asTimingCtrl[2].sFlashTimer),
                            500,
                            Timing_RightFlashHook_500MS);
        }
        else
        {
            // 定时时间为0，停止定时
            Timing_StopRightTiming();
        }        
    }
    else
    {
        // 启动右灶定时
        Timing_StartRightTiming(u8Time);
    }
    return TRUE;
}

void Timing_StartRightTiming(U8 u8Time)
{
    // 确定定时时间
    sDevTiming.asTimingCtrl[2].u16TimingMin = u8Time;
    // 换算成ms
    sDevTiming.asTimingCtrl[2].u32TimingMS = (U32)sDevTiming.asTimingCtrl[2].u16TimingMin
                                            * 60
                                            * 1000;
    // 停止到期定时器
    OS_TimerStop(&(sDevTiming.asTimingCtrl[2].sExpireTimer));
    // 暂停倒计时
    sDevTiming.asTimingCtrl[2].bCountDownFlag = FALSE;    
    // 右灶定时切换至前台
    StateMachine_Change(eDEV_RIGHT_TIMING);  
    // 加键亮
    LED_AddCtrl(eLED_ON);
    // 减键亮
    LED_SubCtrl(eLED_ON);
    // 启动定时器
    OS_TimerRestart(&(sDevTiming.asTimingCtrl[2].sFlashTimer),
                    500,
                    Timing_RightFlashHook_500MS);
}

U32 DevRightTimingCtrl0(U32 arg)
{
    // 显示右灶定时时间
    SMG_ShowNum(sDevTiming.asTimingCtrl[2].u16TimingMin);
    SMG_IconMinute(ON);

    // 查看左灶定时模式是否在运行
    if(TRUE == Timing_CheckLeftTimingRun())
    {
        // 左灶定时半亮，且换至后台
        LED_LeftTimingCtrl(eLED_HALF);
        sDevTiming.asTimingCtrl[0].bCountDownFlag = TRUE;
    }
    else
    {
        // 关闭LED
        LED_LeftTimingCtrl(eLED_OFF);
    }

    // 查看中灶定时模式是否在运行
    if(TRUE == Timing_CheckMidTimingRun())
    {
        // 中灶定时半亮，切换至后台
        LED_MidTimingCtrl(eLED_HALF);
        sDevTiming.asTimingCtrl[1].bCountDownFlag = TRUE;
    }
    else
    {
        // 关闭LED
        LED_MidTimingCtrl(eLED_OFF);
    }
    // 右灶定时按键全亮
    LED_RightTimingCtrl(eLED_ON);
    return STATE_CTRL_INIT;
}

U32 DevRightTimingCtrl1(U32 arg)
{
    return STATE_CTRL_WAIT;
}

Bool Timing_CheckMidTimingExpire(void)
{
    return OS_TimerIsActive(&(sDevTiming.asTimingCtrl[1].sExpireTimer));
}

static void Timing_MidShowENHook_1S(void)
{
    if(eDEV_MID_TIMING != StateMachine_GetCurState())
    {
        // 中灶定时模式不在前台，指示灯灭
        LED_MidTimingCtrl(eLED_OFF);
    }
    else
    {
        // 中灶定时模式在前台，闪烁EN
        if(1== OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[1].sExpireTimer))%2)
        {
            SMG_AllOff();
        }
        else
        {
            SMG_ShowSymbol(eEN);
        }        
    }

    // 10S时间到
    if(10 == OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[1].sExpireTimer)))
    {
        // 若中灶定时还在前台
        if(eDEV_MID_TIMING == StateMachine_GetCurState())
        {
            // 切换到其他定时模式
            if(ON == Timing_CheckLeftTimingRun())
            {
                // 切换到左灶定时模式
                StateMachine_Change(eDEV_LEFT_TIMING);
            }
            else if(ON == Timing_CheckRightTimingRun())
            {
                // 切换到右灶定时模式
                StateMachine_Change(eDEV_RIGHT_TIMING);
            }
            else 
            {
                // 切换到待机模式
                StateMachine_Change(eDEV_STANDBY);
            }              
        }

        // LED灭
        LED_MidTimingCtrl(eLED_OFF);
        // 停止定时器
        OS_TimerStop(&(sDevTiming.asTimingCtrl[1].sExpireTimer));
    }
}

static void Timing_MidTimingExpire(void)
{
    sDevTiming.asTimingCtrl[1].bCountDownFlag = FALSE; // 清除运行标志
    sDevTiming.asTimingCtrl[1].u16TimingMin = 0; // 定时时间清零
    sDevTiming.asTimingCtrl[1].u32TimingMS  = 0; // 定时时间清零
    MidStoveFireOff(); // 关火

    // 判断当前是否为中灶定时显示
    if(eDEV_MID_TIMING == StateMachine_GetCurState())
    {
        // 显示EN
        SMG_ShowSymbol(eEN);
        BuzCtrl(eBUZ_TIME_OUT);
    }
    else
    {
        // LED灭
        LED_MidTimingCtrl(eLED_OFF); 
    }

    // 启动定时结束定时器，倒计时十秒
    OS_TimerStart(&(sDevTiming.asTimingCtrl[1].sExpireTimer),1000,Timing_MidShowENHook_1S);
}

void Timing_StopMidTiming(void)
{
    sDevTiming.asTimingCtrl[1].bCountDownFlag = FALSE; // 清除运行标志
    sDevTiming.asTimingCtrl[1].u16TimingMin = 0; // 定时时间清零
    sDevTiming.asTimingCtrl[1].u32TimingMS  = 0; // 定时时间清零
    LED_MidTimingCtrl(eLED_OFF); // LED灭

    if(TRUE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[1].sExpireTimer)))
    {
        BuzStop();
    }

    // 判断当前是否为中定时模式
    if(eDEV_MID_TIMING == StateMachine_GetCurState())
    {
        // 切换到其他定时模式
        if(ON == Timing_CheckLeftTimingRun())
        {
            // 切换到左灶定时模式
            StateMachine_Change(eDEV_LEFT_TIMING);
        }
        else if(ON == Timing_CheckRightTimingRun())
        {
            // 切换到右灶定时模式
            StateMachine_Change(eDEV_RIGHT_TIMING);
        }
        else 
        {
            // 切换到待机模式
            StateMachine_Change(eDEV_STANDBY);
        }  
    }
}

Bool Timing_CheckMidTimingRun(void)
{
    if(TRUE == sDevTiming.asTimingCtrl[1].bCountDownFlag
	   	|| TRUE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[1].sFlashTimer)))
	{
	  	return TRUE;
	}
	else
	{
	  	return FALSE;
	}
}

Bool Timing_CheckMidFlashTimerActive(void)
{
    return OS_TimerIsActive(&(sDevTiming.asTimingCtrl[1].sFlashTimer));
}

static void Timing_MidFlashHook_500MS(void)
{
    if(eDEV_MID_TIMING != StateMachine_GetCurState())
    {
        // 不是在左定时模式，直接退出
        OS_TimerStop(&(sDevTiming.asTimingCtrl[1].sFlashTimer));
        return;
    }

    // 定时时间闪烁
    if(OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[1].sFlashTimer))%2)
    {
        // 数码管灭
        SMG_AllOff();
        SMG_IconMinute(OFF);
        // 中灶定时按键全灭
        LED_MidTimingCtrl(eLED_OFF);
    }
    else
    {
        // 显示时间
        SMG_ShowNum(sDevTiming.asTimingCtrl[1].u16TimingMin);
        SMG_IconMinute(ON);
        // 中灶定时按键全亮
        LED_MidTimingCtrl(eLED_ON);
    }

    // 定时器到期6次，闪烁三次
    if(6 == OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[1].sFlashTimer)))
    {
        LED_AddCtrl(eLED_OFF);// 加键灭        
        LED_SubCtrl(eLED_OFF);// 减键灭
        
        // 若定时时间修改为0，退出定时模式
        if(sDevTiming.asTimingCtrl[1].u16TimingMin == 0)
        {
            // 退出定时，不关火
            Timing_StopMidTiming();
        }
        else
        {
            // 开始倒计时
            sDevTiming.asTimingCtrl[1].bCountDownFlag = TRUE; 
        }
        // 停止闪烁定时器
        OS_TimerStop(&(sDevTiming.asTimingCtrl[1].sFlashTimer));
        return;
    }
}

void Timing_ComfirmMidTimingTime(void)
{
    LED_AddCtrl(eLED_OFF);// 加键灭        
    LED_SubCtrl(eLED_OFF);// 减键灭

    // 若定时时间修改为0，退出定时模式
    if(sDevTiming.asTimingCtrl[1].u16TimingMin == 0)
    {
        // 退出定时，不关火
        Timing_StopMidTiming();
    }
    else
    {
        // 开始倒计时
        sDevTiming.asTimingCtrl[1].bCountDownFlag = TRUE; 
        // 显示时间
        SMG_ShowNum(sDevTiming.asTimingCtrl[1].u16TimingMin);
        SMG_IconMinute(ON);
        // 中灶定时按键全亮
        LED_MidTimingCtrl(eLED_ON);
    }
    // 停止闪烁定时器
    OS_TimerStop(&(sDevTiming.asTimingCtrl[1].sFlashTimer));    
}

U8 Timing_GetMidTimingTime(void)
{
    return (U8)sDevTiming.asTimingCtrl[1].u16TimingMin;
}

Bool Timing_ChangeMidTimingTime(U8 u8Time)
{
    if(u8Time > 180)
    {
        // 时间格式非法，返回无效标志
        return FALSE;
    }

    if(ON == Timing_CheckMidTimingRun())
    {
        if(u8Time != 0)
        {
            // 修改定时时间
            sDevTiming.asTimingCtrl[1].u16TimingMin = u8Time; 
            // 定时时间换算为ms
            sDevTiming.asTimingCtrl[1].u32TimingMS = (U32)sDevTiming.asTimingCtrl[1].u16TimingMin
                                                            * 60
                                                            * 1000;   
            // 暂停倒计时
            sDevTiming.asTimingCtrl[1].bCountDownFlag = FALSE;
            // 将中灶定时切换至前台
            StateMachine_Change(eDEV_MID_TIMING);
            // 加键亮
            LED_AddCtrl(eLED_ON);
            // 减键亮
            LED_SubCtrl(eLED_ON);
            // 启动左灶定时器
            OS_TimerRestart(&(sDevTiming.asTimingCtrl[1].sFlashTimer),
                            500,
                            Timing_MidFlashHook_500MS);
        }
        else
        {
            // 停止中灶定时
            Timing_StopMidTiming();
        }
    }
    else
    {
        // 启动中灶定时
        Timing_StartMidTiming(u8Time);
    }
    return TRUE;
}

void Timing_StartMidTiming(U8 u8Time)
{
    // 确定定时时间
    sDevTiming.asTimingCtrl[1].u16TimingMin = u8Time;
    // 换算成ms
    sDevTiming.asTimingCtrl[1].u32TimingMS = (U32)sDevTiming.asTimingCtrl[1].u16TimingMin
                                            * 60
                                            * 1000;                                            
    // 停止到期定时器
    OS_TimerStop(&(sDevTiming.asTimingCtrl[1].sExpireTimer));
    // 暂停倒计时
    sDevTiming.asTimingCtrl[1].bCountDownFlag = FALSE;
    // 中灶定时切换至前台
    StateMachine_Change(eDEV_MID_TIMING);   
    // 加键亮
    LED_AddCtrl(eLED_ON);
    // 减键亮
    LED_SubCtrl(eLED_ON);
    // 启动左灶定时器
    OS_TimerRestart(&(sDevTiming.asTimingCtrl[1].sFlashTimer),
                    500,
                    Timing_MidFlashHook_500MS);
}

U32 DevMidTimingCtrl0(U32 arg)
{
    // 显示中灶定时时间
    SMG_ShowNum(sDevTiming.asTimingCtrl[1].u16TimingMin);
    SMG_IconMinute(ON);

    // 查看左灶定时模式是否在运行
    if(TRUE == Timing_CheckLeftTimingRun())
    {
        // 左灶定时半亮，且换至后台
        LED_LeftTimingCtrl(eLED_HALF);
        sDevTiming.asTimingCtrl[0].bCountDownFlag = TRUE;
    }
    else
    {
        LED_LeftTimingCtrl(eLED_OFF);
    }

    // 查看右灶定时模式是否在运行
    if(TRUE == Timing_CheckRightTimingRun())
    {
        // 右灶定时半亮，切换至后台
        LED_RightTimingCtrl(eLED_HALF);
        sDevTiming.asTimingCtrl[2].bCountDownFlag = TRUE;
    }
    else
    {
        LED_RightTimingCtrl(eLED_OFF);
    }
    // 中灶定时按键全亮
    LED_MidTimingCtrl(eLED_ON);
    return STATE_CTRL_INIT;
}

U32 DevMidTimingCtrl1(U32 arg)
{
    return STATE_CTRL_WAIT;
}

Bool Timing_CheckLeftTimingExpire(void)
{
    return OS_TimerIsActive(&(sDevTiming.asTimingCtrl[0].sExpireTimer));
}

static void Timing_LeftShowENHook_1S(void)
{
    if(eDEV_LEFT_TIMING != StateMachine_GetCurState())
    {
        // 左定时模式不在前台，关闭LED 
        LED_LeftTimingCtrl(eLED_OFF);
    }
    else
    {
        // 左定时模式在前台，闪烁EN
        if(1== OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[0].sExpireTimer))%2)
        {
            SMG_AllOff();
        }
        else
        {
            SMG_ShowSymbol(eEN);
        }        
    }
    
    // 10S时间到
    if(10 == OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[0].sExpireTimer)))
    {
        // 左灶定时还在前台
        if(eDEV_LEFT_TIMING == StateMachine_GetCurState())
        {
            // 切换到其他定时模式
            if(ON == Timing_CheckMidTimingRun())
            {
                // 切换到中灶定时模式
                StateMachine_Change(eDEV_MID_TIMING);
            }
            else if(ON == Timing_CheckRightTimingRun())
            {
                // 切换到右灶定时模式
                StateMachine_Change(eDEV_RIGHT_TIMING);
            }
            else 
            {
                // 切换到待机模式
                StateMachine_Change(eDEV_STANDBY);
            }         
        }
        
        // LED熄灭 
        LED_LeftTimingCtrl(eLED_OFF);
        // 停止定时器
        OS_TimerStop(&(sDevTiming.asTimingCtrl[0].sExpireTimer));
    }
}

static void Timing_LeftTimingExpire(void)
{
    sDevTiming.asTimingCtrl[0].bCountDownFlag = FALSE; // 清除运行标志
    sDevTiming.asTimingCtrl[0].u16TimingMin = 0; // 定时时间清零
    sDevTiming.asTimingCtrl[0].u32TimingMS  = 0; // 定时时间清零
    LeftStoveFireOff(); // 关火

    // 判断当前是否处于左灶定时状态
    if(eDEV_LEFT_TIMING == StateMachine_GetCurState())
    {
        // 显示五秒钟EN，定时结束
        SMG_ShowSymbol(eEN);
        BuzCtrl(eBUZ_TIME_OUT);
    }
    else
    {
        LED_LeftTimingCtrl(eLED_OFF); // LED熄灭 
    }

    // 左灶定时结束，启动十秒倒计时
    OS_TimerStart(&(sDevTiming.asTimingCtrl[0].sExpireTimer),1000,Timing_LeftShowENHook_1S);
}

void Timing_StopLeftTiming(void)
{
    sDevTiming.asTimingCtrl[0].bCountDownFlag = FALSE; // 清除运行标志
    sDevTiming.asTimingCtrl[0].u16TimingMin = 0; // 定时时间清零
    sDevTiming.asTimingCtrl[0].u32TimingMS  = 0; // 定时时间清零
    LED_LeftTimingCtrl(eLED_OFF); // LED熄灭

    if(TRUE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[0].sExpireTimer)))
    {
        BuzStop();
    }

    // 判断当前是否为左定时
    if(eDEV_LEFT_TIMING == StateMachine_GetCurState())
    {
        // 切换到其他定时模式
        if(ON == Timing_CheckMidTimingRun())
        {
            // 切换到中灶定时模式
            StateMachine_Change(eDEV_MID_TIMING);
        }
        else if(ON == Timing_CheckRightTimingRun())
        {
            // 切换到右灶定时模式
            StateMachine_Change(eDEV_RIGHT_TIMING);
        }
        else 
        {
            // 切换到待机模式
            StateMachine_Change(eDEV_STANDBY);
        }  
    }
}

Bool Timing_CheckLeftTimingRun(void)
{
    if(TRUE == sDevTiming.asTimingCtrl[0].bCountDownFlag
	   	|| TRUE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[0].sFlashTimer)))
	{
	  	return TRUE;
	}
	else
	{
	  	return FALSE;
	}
}

Bool Timing_CheckLeftFlashTimerActive(void)
{
    return OS_TimerIsActive(&(sDevTiming.asTimingCtrl[0].sFlashTimer));
}

static void Timing_LeftFlashHook_500MS(void)
{
    if(eDEV_LEFT_TIMING != StateMachine_GetCurState())
    {
        // 不是在左定时模式，直接退出
        OS_TimerStop(&(sDevTiming.asTimingCtrl[0].sFlashTimer));
        return;
    }

    // 定时时间闪烁
    if(OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[0].sFlashTimer))%2)
    {
        // 数码管灭
        SMG_AllOff();
        SMG_IconMinute(OFF);
        // 左灶定时按键灭
        LED_LeftTimingCtrl(eLED_OFF);
    }
    else
    {
        // 显示时间
        SMG_ShowNum(sDevTiming.asTimingCtrl[0].u16TimingMin);
        SMG_IconMinute(ON);
        // 左灶定时按键全亮
        LED_LeftTimingCtrl(eLED_ON);
    }

    // 且定时器到期6次
    if(6 == OS_TimerGetExpiredTimes(&(sDevTiming.asTimingCtrl[0].sFlashTimer)))
    {
        LED_AddCtrl(eLED_OFF);// 加键灭        
        LED_SubCtrl(eLED_OFF);// 减键灭

        // 若定时时间修改为0，定时结束
        if(sDevTiming.asTimingCtrl[0].u16TimingMin == 0)
        {
            // 退出定时，不关火
            Timing_StopLeftTiming();
        }
        else
        {
            // 启动倒计时
            sDevTiming.asTimingCtrl[0].bCountDownFlag = TRUE; 
        }
        OS_TimerStop(&(sDevTiming.asTimingCtrl[0].sFlashTimer));
        return;
    }
}

void Timing_ComfirmLeftTimingTime(void)
{
    LED_AddCtrl(eLED_OFF);// 加键灭        
    LED_SubCtrl(eLED_OFF);// 减键灭

    // 若定时时间修改为0，定时结束
    if(sDevTiming.asTimingCtrl[0].u16TimingMin == 0)
    {
        // 退出定时，不关火
        Timing_StopLeftTiming();
    }
    else
    {
        // 启动倒计时
        sDevTiming.asTimingCtrl[0].bCountDownFlag = TRUE; 
        // 显示时间
        SMG_ShowNum(sDevTiming.asTimingCtrl[0].u16TimingMin);
        SMG_IconMinute(ON);
        // 左灶定时按键全亮
        LED_LeftTimingCtrl(eLED_ON);
    }
    OS_TimerStop(&(sDevTiming.asTimingCtrl[0].sFlashTimer));    
}

U8 Timing_GetLeftTimingTime(void)
{
    return (U8)sDevTiming.asTimingCtrl[0].u16TimingMin;
}

Bool Timing_ChangeLeftTimingTime(U8 u8Time)
{
    // 设置时间格式非法
    if(u8Time > 180)
    {
        return FALSE;
    }
    
    // 查询左灶定时模式是否开启
    if(ON == Timing_CheckLeftTimingRun())
    {
        if(u8Time != 0)
        {
            // 修改定时时间
            sDevTiming.asTimingCtrl[0].u16TimingMin = u8Time; 
            // 定时时间换算为ms
            sDevTiming.asTimingCtrl[0].u32TimingMS = (U32)sDevTiming.asTimingCtrl[0].u16TimingMin
                                                            * 60
                                                            * 1000;      
            // 暂停定时
            sDevTiming.asTimingCtrl[0].bCountDownFlag = FALSE;
            // 左灶定时模式切换至前台
            StateMachine_Change(eDEV_LEFT_TIMING);
            // 加键亮
            LED_AddCtrl(eLED_ON);
            // 减键亮
            LED_SubCtrl(eLED_ON);
            // 启动闪烁定时器
            OS_TimerRestart(&(sDevTiming.asTimingCtrl[0].sFlashTimer),
                            500,
                            Timing_LeftFlashHook_500MS);
        }
        else
        {
            // 停止定时
            Timing_StopLeftTiming();
        }        
    }
    else
    {
        // 启动左灶定时
        Timing_StartLeftTiming(u8Time);
    }
    return TRUE;
}

void Timing_StartLeftTiming(U8 u8Time)
{
    // 确定定时时间
    sDevTiming.asTimingCtrl[0].u16TimingMin = u8Time;
    // 换算成ms
    sDevTiming.asTimingCtrl[0].u32TimingMS = (U32)sDevTiming.asTimingCtrl[0].u16TimingMin
                                            * 60
                                            * 1000;
    // 停止到期定时器
    OS_TimerStop(&(sDevTiming.asTimingCtrl[0].sExpireTimer));
    // 暂停倒计时
    sDevTiming.asTimingCtrl[0].bCountDownFlag = FALSE;                                        
    // 左灶定时切换至前台
    StateMachine_Change(eDEV_LEFT_TIMING); 
    // 加键亮
    LED_AddCtrl(eLED_ON);
    // 减键亮
    LED_SubCtrl(eLED_ON);
    // 启动闪烁定时器
    OS_TimerRestart(&(sDevTiming.asTimingCtrl[0].sFlashTimer),
                    500,
                    Timing_LeftFlashHook_500MS);
}

U32 DevLeftTimingCtrl0(U32 arg)
{
    // 显示左灶定时时间
    SMG_ShowNum(sDevTiming.asTimingCtrl[0].u16TimingMin);
    SMG_IconMinute(ON);

    // 查看中灶定时模式是否在运行
    if(TRUE == Timing_CheckMidTimingRun())
    {
        // 中灶定时半亮，且换至后台
        LED_MidTimingCtrl(eLED_HALF);
        sDevTiming.asTimingCtrl[1].bCountDownFlag = TRUE;
    }
    else
    {
        LED_MidTimingCtrl(eLED_OFF);
    }

    // 查看右灶定时模式是否在运行
    if(TRUE == Timing_CheckRightTimingRun())
    {
        // 右灶定时半亮，切换至后台
        LED_RightTimingCtrl(eLED_HALF);
        sDevTiming.asTimingCtrl[2].bCountDownFlag = TRUE;
    }
    else
    {
        LED_RightTimingCtrl(eLED_OFF);
    }
    
    // 左灶定时按键全亮
    LED_LeftTimingCtrl(eLED_ON);
    return STATE_CTRL_INIT;
}

U32 DevLeftTimingCtrl1(U32 arg)
{
    return STATE_CTRL_WAIT;
}

Bool Timing_AddSubKeyPressHook(KeyCtrlType_te eKeyType,TimingMode_te eTimingMode)
{
    switch (eTimingMode)
    {
    case eLEFT_TIMING:
        // 判断闪烁定时器是否开启
        if(FALSE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[0].sFlashTimer)))
        {
            // 若未开启，不能调参数，返回蜂鸣器无效
            return FALSE;
        }
        // 加键处理
        if(eKEY_ADD_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[0].u16TimingMin++;

            if(sDevTiming.asTimingCtrl[0].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[0].u16TimingMin = 0;
            }
        }
        // 加键长按
        else if(eKEY_ADD_LONG_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[0].u16TimingMin += 5;

            if(sDevTiming.asTimingCtrl[0].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[0].u16TimingMin = 0;
            }
        }
        // 减键处理
        else if(eKEY_SUB_PRESS == eKeyType)
        {
            if(sDevTiming.asTimingCtrl[0].u16TimingMin ==  0)
            {
                sDevTiming.asTimingCtrl[0].u16TimingMin = 180;
            }
            else
            {
                sDevTiming.asTimingCtrl[0].u16TimingMin--;
            }
        }
        // 减键长按处理
        else if(eKEY_SUB_LONG_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[0].u16TimingMin -= 5;

            if(sDevTiming.asTimingCtrl[0].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[0].u16TimingMin = 180;
            }
        }
        // 先暂停倒计时
        sDevTiming.asTimingCtrl[0].bCountDownFlag = FALSE;
        // 定时时间换算为ms
        sDevTiming.asTimingCtrl[0].u32TimingMS = (U32)sDevTiming.asTimingCtrl[0].u16TimingMin
                                                * 60
                                                * 1000;  
        // 将左灶定时切换至前台
        StateMachine_Change(eDEV_LEFT_TIMING);
        // 加键亮
        LED_AddCtrl(eLED_ON);
        // 减键亮
        LED_SubCtrl(eLED_ON);
        // 启动左灶定时器
        OS_TimerRestart(&(sDevTiming.asTimingCtrl[0].sFlashTimer),
                        500,
                        Timing_LeftFlashHook_500MS);
        return TRUE;
    break;
    case eMID_TIMING:
        // 判断闪烁定时器是否开启
        if(FALSE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[1].sFlashTimer)))
        {
            // 若未开启，不能调参数，提前提出
            return FALSE;
        }
        // 加键处理
        if(eKEY_ADD_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[1].u16TimingMin++;

            if(sDevTiming.asTimingCtrl[1].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[1].u16TimingMin = 0;
            }
        }
        // 加键长按
        else if(eKEY_ADD_LONG_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[1].u16TimingMin += 5;

            if(sDevTiming.asTimingCtrl[1].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[1].u16TimingMin = 0;
            }
        }
        // 减键处理
        else if(eKEY_SUB_PRESS == eKeyType)
        {
            if(sDevTiming.asTimingCtrl[1].u16TimingMin ==  0)
            {
                sDevTiming.asTimingCtrl[1].u16TimingMin = 180;
            }
            else
            {
                sDevTiming.asTimingCtrl[1].u16TimingMin--;
            }
        }
        // 减键长按处理
        else if(eKEY_SUB_LONG_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[1].u16TimingMin -= 5;

            if(sDevTiming.asTimingCtrl[1].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[1].u16TimingMin = 180;
            }
        }
        // 先暂停倒计时
        sDevTiming.asTimingCtrl[1].bCountDownFlag = FALSE;
        // 定时时间换算为ms
        sDevTiming.asTimingCtrl[1].u32TimingMS = (U32)sDevTiming.asTimingCtrl[1].u16TimingMin
                                                * 60
                                                * 1000;  
        // 将中灶定时切换至前台
        StateMachine_Change(eDEV_MID_TIMING);
        // 加键亮
        LED_AddCtrl(eLED_ON);
        // 减键亮
        LED_SubCtrl(eLED_ON);
        // 启动左灶定时器
        OS_TimerRestart(&(sDevTiming.asTimingCtrl[1].sFlashTimer),
                        500,
                        Timing_MidFlashHook_500MS);
        return TRUE;
    break;
    case eRIGHT_TIMING:
        // 判断闪烁定时器是否开启
        if(FALSE == OS_TimerIsActive(&(sDevTiming.asTimingCtrl[2].sFlashTimer)))
        {
            // 若未开启，不能调参数，提前提出
            return FALSE;
        }
        // 加键处理
        if(eKEY_ADD_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[2].u16TimingMin++;

            if(sDevTiming.asTimingCtrl[2].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[2].u16TimingMin = 0;
            }
        }
        // 加键长按
        else if(eKEY_ADD_LONG_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[2].u16TimingMin += 5;

            if(sDevTiming.asTimingCtrl[2].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[2].u16TimingMin = 0;
            }
        }
        // 减键处理
        else if(eKEY_SUB_PRESS == eKeyType)
        {
            if(sDevTiming.asTimingCtrl[2].u16TimingMin ==  0)
            {
                sDevTiming.asTimingCtrl[2].u16TimingMin = 180;
            }
            else
            {
                sDevTiming.asTimingCtrl[2].u16TimingMin--;
            }
        }
        // 减键长按处理
        else if(eKEY_SUB_LONG_PRESS == eKeyType)
        {
            sDevTiming.asTimingCtrl[2].u16TimingMin -= 5;

            if(sDevTiming.asTimingCtrl[2].u16TimingMin > 180)
            {
                sDevTiming.asTimingCtrl[2].u16TimingMin = 180;
            }
        }
        // 先暂停倒计时
        sDevTiming.asTimingCtrl[2].bCountDownFlag = FALSE;
        // 定时时间换算为ms
        sDevTiming.asTimingCtrl[2].u32TimingMS = (U32)sDevTiming.asTimingCtrl[2].u16TimingMin
                                                * 60
                                                * 1000;  
        // 将右灶定时切换至前台
        StateMachine_Change(eDEV_RIGHT_TIMING);
        // 加键亮
        LED_AddCtrl(eLED_ON);
        // 减键亮
        LED_SubCtrl(eLED_ON);
        // 启动定时器
        OS_TimerRestart(&(sDevTiming.asTimingCtrl[2].sFlashTimer),
                        500,
                        Timing_RightFlashHook_500MS);
        return TRUE;
    break;
    }
	return FALSE;
}

void Timing_Hook_1MS(void)
{
    // 左灶定时模式运行中 
    if(TRUE == sDevTiming.asTimingCtrl[0].bCountDownFlag)
    {
        // 定时时间未减完
        if(sDevTiming.asTimingCtrl[0].u32TimingMS > 0)
        {
            // 定时时间ms自减
            sDevTiming.asTimingCtrl[0].u32TimingMS--;

            // 一分钟时间到
            if((sDevTiming.asTimingCtrl[0].u32TimingMS % 60000) == 0)
            {
                // 定时时间Min自减
                sDevTiming.asTimingCtrl[0].u16TimingMin--;
                // 查询当前是否为左灶定时，显示分钟
                if(eDEV_LEFT_TIMING == StateMachine_GetCurState())
                {
                    // 刷新显示
                    SMG_ShowNum(sDevTiming.asTimingCtrl[0].u16TimingMin);
                    SMG_IconMinute(ON);
                }
            }

            // 判断定时时间是否小于一分钟
            if(sDevTiming.asTimingCtrl[0].u32TimingMS <= 60*u16SEC_TO_MSEC)
            {
                // 查询当前是否为左灶定时，显示秒
                if(eDEV_LEFT_TIMING == StateMachine_GetCurState())
                {
                    // 刷新显示
                    SMG_ShowNum(sDevTiming.asTimingCtrl[0].u32TimingMS/1000);
                    SMG_IconMinute(OFF); 
                }
            }
            
            // 判断定时时间是否到倒数第十秒
            if(sDevTiming.asTimingCtrl[0].u32TimingMS == 10*u16SEC_TO_MSEC)
            {
                // 倒数第十秒，蜂鸣器报警
                BuzCtrl(eBUZ_TIME_OUT);
            }
            // 判断定时时间是否结束
            else if(sDevTiming.asTimingCtrl[0].u32TimingMS == 0)
            {
                // 左灶定时已到期，关火
                Timing_LeftTimingExpire();
            }
        }
    }

    // 中灶定时模式运行中 
    if(TRUE == sDevTiming.asTimingCtrl[1].bCountDownFlag)
    {
        // 定时时间未减完
        if(sDevTiming.asTimingCtrl[1].u32TimingMS > 0)
        {
            // 定时时间ms自减
            sDevTiming.asTimingCtrl[1].u32TimingMS--;

            // 一分钟时间到
            if((sDevTiming.asTimingCtrl[1].u32TimingMS % 60000) == 0)
            {
                // 定时时间Min自减
                sDevTiming.asTimingCtrl[1].u16TimingMin--;
                // 查询当前是否为中灶定时，倒计时显示分钟
                if(eDEV_MID_TIMING == StateMachine_GetCurState())
                {
                    // 刷新显示
                    SMG_ShowNum(sDevTiming.asTimingCtrl[1].u16TimingMin);
                    SMG_IconMinute(ON);
                }
            }
            
            // 判断定时时间是否小于一分钟
            if(sDevTiming.asTimingCtrl[1].u32TimingMS <= 60*u16SEC_TO_MSEC)
            {
                // 查询当前是否为中灶定时，倒计时显示秒
                if(eDEV_MID_TIMING == StateMachine_GetCurState())
                {
                    // 刷新显示
                    SMG_ShowNum(sDevTiming.asTimingCtrl[1].u32TimingMS/1000);
                    SMG_IconMinute(OFF); 
                }
            }

            // 判断定时时间是否到倒数第十秒
            if(sDevTiming.asTimingCtrl[1].u32TimingMS == 10*u16SEC_TO_MSEC)
            {
                // 倒数第十秒，蜂鸣器报警
                BuzCtrl(eBUZ_TIME_OUT);
            }
            // 判断定时时间是否结束
            else if(sDevTiming.asTimingCtrl[1].u32TimingMS == 0)
            {
                // 定时已结束，关火
                Timing_MidTimingExpire();
            }
        }
    }

    // 右灶定时模式运行中 
    if(TRUE == sDevTiming.asTimingCtrl[2].bCountDownFlag)
    {
        // 定时时间未减完
        if(sDevTiming.asTimingCtrl[2].u32TimingMS > 0)
        {
            // 定时时间ms自减
            sDevTiming.asTimingCtrl[2].u32TimingMS--;

            // 一分钟时间到
            if((sDevTiming.asTimingCtrl[2].u32TimingMS % 60000) == 0)
            {
                // 定时时间Min自减
                sDevTiming.asTimingCtrl[2].u16TimingMin--;
                // 查询当前是否为右灶定时，倒计时显示分
                if(eDEV_RIGHT_TIMING == StateMachine_GetCurState())
                {
                    // 刷新显示
                    SMG_ShowNum(sDevTiming.asTimingCtrl[2].u16TimingMin);
                    SMG_IconMinute(ON);
                }
            }

            // 判断定时时间是否小于一分钟
            if(sDevTiming.asTimingCtrl[2].u32TimingMS <= 60*u16SEC_TO_MSEC)
            {
                // 查询当前是否为右灶定时，倒计时显示秒
                if(eDEV_RIGHT_TIMING == StateMachine_GetCurState())
                {
                    // 刷新显示
                    SMG_ShowNum(sDevTiming.asTimingCtrl[2].u32TimingMS/1000);
                    SMG_IconMinute(OFF); 
                }
            }
            
            // 判断定时时间是否到倒数第十秒
            if(sDevTiming.asTimingCtrl[2].u32TimingMS == 10*u16SEC_TO_MSEC)
            {
                // 倒数第十秒，蜂鸣器报警
                BuzCtrl(eBUZ_TIME_OUT);
            }
            // 判断定时时间是否结束
            else if(sDevTiming.asTimingCtrl[2].u32TimingMS == 0)
            {
                // 定时已结束，关火
                Timing_RightTimignExpire();
            }
        }
    }
}

